SPACE 1/SPACE - Library 1 - Volume 1.iso/utilitys/613/access/access.txt

Text File | 1991-10-19 | 29.0 KB | 1,043 lines

PRESS RELEASE - 1/7/90

******    ****    ****   *    *
*     *  *    *  *    *  *   *
*     *  *    *  *       *  *
******   *    *  *       ***
*   *    *    *  *       *  *
*    *   *    *  *    *  *   *
*     *   ****    ****   *    *

****    *****   ****   *****  *****    *    *
*   *     *    *         *      *     * *   *
*    *    *    *         *      *    *   *  *
*    *    *    *  ***    *      *    *****  *
*    *    *    *    *    *      *    *   *  *
*   *     *    *    *    *      *    *   *  *
****    *****   ****   *****    *    *   *  *****


Rock Digital
2901 Kenmore Avenue
Dayton, OH  45420
[phone]

****************************************************************
If your going to PRINT this file, please set printer to CONDENSED
mode, as this text contains some long lines that should not be
broken!
****************************************************************


Thank you for downloading the demo version of .ACCess!  We hope
you give it a good workout and find it useful.

Following is a reprint of the .ACCess! review printed in December
89 issue of ATARI INTERFACE MAGAZINE.  After the review we added
a few notes concerning the Release 3 demo version.  If you decide
to purchase .ACCess! ask your local Atari dealer to get it OR
send $29.95 to:

Rock Digital
2901 Kenmore Avenue
Dayton, Ohio  45420
[phone]


****************************************************************
****************************************************************


.ACCess!
by Bill Rayl


     The ingenuity of ST programmers simply amazes me at times,
and this is definitely one of them.

     .ACCess!, from Rock Digital, is a handy desk accessory (DA)
that gives you all the flexibility of a Command Line Interpreter
(CLI).  With .ACCess!, you can copy/delete/rename/move files, get
disk directories, copy files and more from within any GEM program
allowing access to the GEM menu bar.

     Sure, there are a number of desk accessories available that
allow you to do those things, as well.  But, .ACCess! has many
more features...and .ACCess! gives you a CLI within a GEM window.
You can resize the window, drag it to one corner of your screen
and be able to switch back and forth from .ACCess! to your
program.

     You can create "batch" files and run them within .ACCess!,
and though "not supported" by Rock Digital, .ACCess! can execute
TOS and TTP programs, often "tricking" them to run inside the
.ACCess! GEM window.  You can even run some GEM programs from
within this desk accessories!

     In a word, .ACCess! is...umm...elegant.  Yea...it's elegant.
It's kinda cute, too.

     And for all you memory misers who refuse to use desk
accessories, Rock Digital has kindly provided a TOS version of
their program.  You won't get the GEM window, and the added
flexibility that comes with that window, but you do get a first-
rate Command Line Interpreter.

     If you're a user of programs such as DCopy or a "DOS Shell"
program, you surely appreciate the added power and flexibility of
a CLI...especially for file manipulation.  If you've never used a
CLI or worked in an MS-DOS environment, and never felt a need for
more than what the ST desktop has to offer, you may not need what
.ACCess! has to offer.

     Just try copying over 100 files from one folder on drive A
to a different folder three levels deep on a hard drive using the
standard desktop, and you'll understand immediately how useful a
product like .ACCess! can be.

     With the unique feature of being the ONLY CLI (known to me)
in a GEM window, .ACCess! becomes doubly useful.

     For example, I was recently leaving a message on CompuServe
and found I needed to quote from a text file I had previously
stored on my hard drive.  Using .ACCess!, I was able to type the
file out and, while viewing the quote in the .ACCess! window, I
added it to the message on CompuServe.

     Without .ACCess!, I would have had two options.  I could
have used the VIEW command in Flash! to type the file to my
screen, written down or memorized the quote and then typed it in.

     Or, I could have loaded the text into the Flash! capture
buffer (after saving what I already had loaded there), found the
quote I wanted, separated it from the surrounding text with
carriage returns, selected the quote as block of text and then
uploaded it directly into the CompuServe message.

     All this for a couple lines of text.  Makes me tired just
writing about it!

     In all, nearly 40 commands, 22 programming functions and 12
control flow/batch processing keywords are available via
.ACCess!.  Rock Digital has produced a desk accessory that is
both highly useful and very innovative.  Check this one out!

Rock Digital
2901 Kenmore Avenue
Dayton, OH  45420
[phone]


****************************************************************
****************************************************************


The review above was based on Release 2.2 of .ACCess!.  Since
this time we have "done our homework" and come up with some more
features and enhancements!

(Note: .ACCess! 2.2 owners make SURE you send in your
registration cards,  you will receive Release 3 and new manual
FREE!)


ADDED COMMANDS FOR RELEASE 3
****************************

FONT command is now available to allow switching of fonts
interactively or in batch mode.

CLS command has been added.  This command clears screen (or
window) and places the cursor in upper left hand corner.

PRINT command has been added to allow ASCII files to be printed
quickly and easily.

FORMAT command has been added to format disks into a variety of
formats!

An ACCESS.TTP files is now supplied to allow you to pass a
command or batch process to it for processing.

An ACCESS_A.PRG file is now supplied to allow AUTO folder batch
processing on bootup!

An ACCESS.TOS version of .ACCess! is supplied with Release 3,
same as Release 2.2


WHAT DO I GET IN THE DEMO VERSION?
**********************************

The demo of .ACCess! you just downloaded contains a striped down
version of the Desk Accessory and TOS versions of .ACCess!.  The
demo version only knows how to do two things.  Display
directories and process a subset of batch functions.  All the
other commands such as copy, move, rename... have been striped
from the demo version.

Built-in commands and functions contained in demo version:
     *, +, -, /, <, <=, =, >, >=, ?, and, ascii, batch, block,
     cd, chdir, chr,date, defaults, dir, drive, dtnum, echo,
     else, elseif, eof, exit, export,filedt, filestat, font,
     for, help, if, input, justify, length, ls, md,mkdir, pwd,
     rd, rmdir, segment, set, tail, time, variables, ver,
     version,while

But, to illustrate the true power that .ACCess! provides, we
have rewritten most of the standard MS-DOS like commands using
batch files.  What you say?  Yes, the following commands are
suported through the use of .ACCess! batch files.

Simulated commands for demo version (some not fully functional):
     and, cat, cls, concat, copy, cp, create, delete, dir, erase,
     ext, extension, full, head, justify, length, ls, mod, move,
     mv, not, or, pos, position, print, prompt, quit, rename,
     return, rm, rn, root, tail, type, unlink

Commands not supported in demo verison:
    chkdsk, color, du, format, res, resolution, rndir, touch, verify


HOW TO SETUP DEMO VERSION?
**************************

1) Create a folder called ACCESS.  Create another folder inside
ACCESS called BATCH.

2) Copy ALL batch files (i.e. the ones that have file extensions
.BAT) into BATCH folder.

3) Copy rest of files into ACCESS folder.

4) Copy ACCESS_D.ACC onto root directory of boot disk.

5) Reboot computer is install .ACCess! Desk Accessory.

6) When ACCESS is executed (or called up from list of desk
accessories) use SET PATH command to set the path variable to
correct BATCH folder.  This will allow you to use the emulated
ACCess! commands.

For Example,

SET PATH \ACCESS\BATCH

7) You can use to VARIABLES command to display system variables.

8) After .ACCess! window is open, click on it again out of the
list of Desk Accessories to change displayed font size.

9) The last and most important step is to purchase .ACCess! from
your local dealer!  <grin>


SYNTAX OF .ACCess! COMMANDS (Full Version)
**********************************************

    * <number> <number>{ <number>} :: <number>
        Returns the product

        Example
            echo {9 * 2 = }!{* 9 2}{\n}
        Output
            9 * 2 = 18

    + <number> <number>{ <number>} :: <number>
        Returns the sum

        Example
            echo {9 + 2 = }!{+ 9 2}{\n}
        Output
            9 + 2 = 11

    - <number> <number> :: <number>
        Returns the difference

        Example
            echo {9 - 2 = }!{- 9 2}{\n}
        Output
            9 - 2 = 7

    / <number> <number> :: <number>
        Returns the integer quotient

        Example
            echo {9 / 2 = }!{/ 9 2}{\n}
        Output
            9 / 2 = 4

    < <number> <number> :: [OK]
        Returns a non-empty string only if first number is
        less than second

        Example
            if !{< 9 2}
                echo {TRUE\n}
            else
                echo {FALSE\n}
        Output
            FALSE

    <= <number> <number> :: [OK]
        Returns a non-empty string only if first number is
        less than or equal to second

        Example
            if !{<= 9 2}
                echo {TRUE\n}
            else
                echo {FALSE\n}
        Output
            FALSE

    =[ -c] <arbitrary> <arbitrary> :: [OK]
        Returns a non-empty string only if first argument is
        equal to the second

        -c will make the compare case sensitive

        Example
            if !{= 9 2}
                echo {TRUE\n}
            else
                echo {FALSE\n}
        Output
            FALSE

    > <number> <number> :: [OK]
        Returns a non-empty string only if first number is
        greater than second

        Example
            if !{> 9 2}
                echo {TRUE\n}
            else
                echo {FALSE\n}
        Output
            TRUE

    >= <number> <number> :: [OK]
        Returns a non-empty string only if first number is
        greater than or equal to second

        Example
            if !{>= 9 2}
                echo {TRUE\n}
            else
                echo {FALSE\n}
        Output
            TRUE

    ? (see help)

    and <arbitrary> <arbitrary> :: [OK]
        Returns a non-empty string only if both arguments
        are non-empty

        Example
            if !{and {OK} {}}
                echo {TRUE\n}
            else
                echo {FALSE\n}
        Output
            FALSE

    ascii <character> :: <number>
        Returns the ascii value

        Example
            echo {Ascii value of A = }!{ascii A}{\n}
        Output
            Ascii value of A = 65

    attrib[ -r][ -h][ -s][ -a] <search pathname>
        Marks attributes of files with read only being the
        default

        -r marks read only
        -h marks hidden
        -s marks system
        -a marks archive

        Example
            attrib -s -h ^c:\*.sys
        Result
            Marks all files in device c: with extension
            of sys as system and hidden

    batch[ <pathname>{ <arbitrary>}]
        Interprets command block in file
        Number variables are saved

        <arbitrary> is put into the corresponding number
        variable

        Example
            batch access.bat
        Result
            Interprets access.bat

    block<NEW LINE><command block>
        Does the command block

        Example
            block > test
                echo {Hello world!\n}
        Result
            "Hello world!" is written to test

    cat (see type)

    cd (see chdir)

    chdir <pathname>
        Changes the current directory

        Example
            chdir \auto
        Result
            The current directory is changed to \auto

    chkdsk[ <device>]
        Gets statistics

        Example
            chkdsk c:
        Result
            The statistics of c: are displayed

    chr <number> :: <character>
        Returns character corresponding to the ascii value

        Example
            echo {Character with ascii value 65 = }!{chr 65}{\n}
        Output
            Character with ascii value 65 = A

    cls
        Clears the screen

        Example
            cls
        Result
            The screen is cleared

    color <number> <number>
        Changes the color register

        Example
            color 0 15
        Result
            sets color register 0 to blue

    concat <arbitrary> <arbitrary>{ <arbitrary>} :: <arbitrary>
        Returns the concatenation of the arguments

        Example
            echo {Concatenation of a, b, and c = }!{concat a b c}{\n}
        Output
            Concatenation of a, b, and c = abc

    copy[ -q][ -a][ -o] <search pathname>[ <search pathname>]
        Copies files and subdirectories

        -q queries for each file
        -a appends if destination exists
        -o overwrites if destination exists

        Example
            copy -q ^a:\ work\
        Result
            Copies requested files and subdirectories
            from a:\ to work\

    cp (see copy)

    create[ -a][ -o][ <pathname>]
        Creates a file from the console

        -a appends if destination exists
        -o overwrites if destination exists

        Example
            create test
        Result
            Creates test and puts user input into it

    date[ <date>] :: <date>
        Returns the date

        <date> will change the date

        Example
            echo {Current date is }!date{\n}
        Output
            Current date is <current date>

    defaults{ -[!]<character><arbitrary>}
        Sets default options on all commands and functions

        Example
            defaults -w
        Result
            Makes -w a default option on all commands

    delete[ -n] <search pathname>
        Deletes files and subdirectories

        -n does not query for each file

        Example
            delete -n ^temp\
        Result
            Delete all files in temp directory without
            asking user

    dir[ -w][ -a] <search pathname>
        Lists directory

        -w shows files across the width of the screen
        -a shows every file

        Example
            dir ..,^a:\
        Result
            Lists parent directory and directory tree of a:

    drive :: <device>
        Returns current drive

        Example
            echo {Current drive is }!drive{\n}
        Output
            Current drive is <current drive>

    dtnum <date>[ <time>] :: <number>
        Returns a number corresponding to date and time

        Example
            if !{> !{dtnum 9-9-89} !{dtnum 2-2-89}}
                echo {TRUE\n}
            else
                echo {FALSE\n}
        Output
            TRUE

    du (see chkdsk)

    echo <arbitrary>{ <arbitrary>}
        Puts the arguments to the screen separated by spaces

        Example
            echo {Hello world!\n}
        Result
            "Hello world!" is written

    else<NEW LINE><command block>
        Does the command block when if or elseif is not done

        See example in if command

    elseif <arbitrary><NEW LINE><command block>
        Does the command block when if or elseif is not
        done and argument is non-empty

        See example in if command

    eof :: [OK]
        Returns a non-empty string only if it is the end
        of standard input

        Example
            block < access.bat
                while !{not !eof}
                    echo !input{\n}
        Output
            <contents of access.bat>

    erase (see delete)

    execute <pathname>{ <arbitrary>}
        Not available in accessory versions
        Executes program

        <arbitrary> is passed to program

        Example
            execute test.tos
        Result
            Executes test.tos

    exit[ <number>[ <arbitrary>]]
        Exits command block

        <number> causes that many nested commands blocks
        to be exited
        <arbitrary> is returned

        Example
            exit 3
        Result
            Exits 3 levels

    export <variable name>[ <arbitrary>]
        Exports a variable to the environment

        <arbitrary> sets the variable

        Example
            export path
        Result
            The path variable is moved to the environment

    ext (see extension)

    extension <pathname> :: <extension>
        Returns the extension

        Example
            echo {Extension of c:\auto\access.bat = }!{extension c:\auto\access.bat}{\n}
        Output
            Extension of c:\auto\access.bat = bat

    filedt <pathname>[ <date>[ <time>]] :: [<date> <time>]
        Returns the date and time of a file

        <date> sets the date of the file
        <time> sets the time of the file

        Example
            echo {Date of access.bat = }!{filedt access.bat}{\n}
        Output
            Date of access.bat = <date of access.bat>

    filestat <pathname> :: [(R| )(H| )(S| )(A| )(V| )(D| )]
        Returns file statistics

        R is for read only
        H is for hidden
        S is for system
        A is for archive
        V is for volume label
        D is for directory

        Example
            echo {Statistics of access.bat = }!{filestat access.bat}{\n}
        Output
            Statistics of access.bat = <statistics of access.bat>

    font[ <number>]
        Only available in accessory versions
        Changes the font
        If no number is specified the default font is used

        -1 - changes the font to one lower
        0 - 6x6 font
        1 - 8x8 font
        2 - 8x16 font

        Example
            font 0
        Result
            Font is changed to the 6x6 font

    for[ -d] <variable name> <search pathname>[ <search pathname>]<NEW LINE><command block>
        Does the command block for every match of the first search pathname
        If the variable name is a number
            $<variable name> will be the pathname match
            ${<variable name>+1} will be the corresponding other pathname
            ${<variable name>+2} will be the file size
            ${<variable name>+3} will be the file statistics(same as filestat)
            ${<variable name>+4} will be the file date and time
        Else
            ${<variable name>_pathname} will be the pathname match
            ${<variable name>_destination} will be the corresponding other pathname
            ${<variable name>_size} will be the file size
            ${<variable name>_stat} will be the file statistics(same as filestat)
            ${<variable name>_date} will be the file date and time
        If a tree search is done
            The file statistics will be ">>>>>>" when entering a directory
            The file statistics will be "<<<<<<" when exiting a directory
        The for command has an extra level for exiting the loop

        -d causes directories to be included in the search

        Example
            for -d x \*.*
                echo $x_pathname{ }$x_size{ }$x_stat{ }$x_date{\n}
        Result
            The files and directories in the root will be displayed

    full <pathname> :: <pathname>
        Returns the full pathname

        Example
            echo {Full pathname of access.bat = }!{full access.bat}{\n}
        Output
            Full pathname of access.bat = <current drive><current path>\access.bat

    head <pathname> :: <pathname>
        Returns the path

        Example
            echo {Head of c:\auto\access.bat = }!{head c:\auto\access.bat}{\n}
        Output
            Head of c:\auto\access.bat = c:\auto\

    help[ <command name>]
        Gives commands

        <command name> gives help on one command

        Example
            help dir
        Result
            The syntax of dir is displayed

    if <arbitrary><NEW LINE><command block>
        Does command block if argument is non-empty

        Example
            if !{< $x 3}
                echo {$x < 3\n}
                if !{< $x 0}
                    exit 2
                echo {$x >= 0\n}
            elseif !{< $x 10}
                echo {3 <= $x < 10\n}
            else
                echo {$x >= 10\n}
        Result
            If $x < 0
                "$x < 3" is displayed
            If 0 <= $x <3
                "$x < 3" and "$x >= 0" are displayed
            If 3 <= $x < 10
                "3 <= $x < 10" is  displayed
            If $x >= 10
                "$x >= 10" is displayed

    input[ -d<arbitrary>][ -c]{ <arbitrary>}
        Returns input from console

        -d displays a default line for input
        -c makes just one character to be inputed
        <arbitrary> is display before the input

        Example
            echo {Hi }!{input {What is your name?}}{!\n}
        Output
            What is your name? (input your name)
            Hi <your name>!

    justify <arbitrary> <number> :: <arbitrary>
        Returns the argument right-justified by the number
        If the number is negative it is left-justified

        Example
            echo {Justification abc justified by 8 = }!{justify abc 8}{\n}
        Output
            Justification abc by 8 = <5 spaces>abc

    launch <pathname>{ <arbitrary>}(not available in accessory versions)
        Not available in accessory versions
        Launches a GEM application

        <arbitrary> is passed to the application

        Example
            launch test.prg
        Result
            Executes test.prg with cursor off and mouse on

    length <arbitrary> :: <number>
        Return the length of the argument

        Example
            echo {Length of abc = }!{length abc}{\n}
        Output
            Length of abc = 3

    ls[ -l][ -a] <search pathname>
        Lists directory

        -l shows a long listing with size, statistics, time, and date
        -a shows every file

        Example
            ls ..,^a:\
        Result
            Lists parent directory and directory tree of a:

    md (see mkdir)

    mk (see create)

    mkdir <pathname>
        Makes a directory

        Example
            mkdir test
        Result
            Makes directory test

    mod <number> <number> :: <number>
        Returns the modula(remainder)

        Example
            echo {9 mod 2 = }!{mod 9 2}{\n}
        Output
            9 mod 2 = 1

    move[ -q][ -a][ -o] <search pathname>[ <search pathname>]
        Moves files

        -q queries for each file
        -a appends if destination exists
        -o overwrites if destination exists

        Example
            move ^a:\ work\
        Result
            Moves files and subdirectories from a:\ to work\

    mv (see move)

    not <arbitrary> :: [OK]
        Returns a non-empty string only if the argument is empty

        Example
            if !{not {OK}}
                echo {TRUE\n}
            else
                echo {FALSE\n}
        Output
            FALSE

    or <arbitrary> <arbitrary> :: [OK]
        Returns a non-empty string only if one of the arguments is non-empty

        Example
            if !{or {OK} {}}
                echo {TRUE\n}
            else
                echo {FALSE\n}
        Output
            TRUE

    path[ <device>] :: <pathname>
        Returns the current directory

        <device> will use a different device

        Example
            echo {Current path is }!path{\n}
        Output
            Current path is <current path>

    pos (see position)

    position <number> <number>
        Positions the cursor at is x and y coordinate

        Example
            position 40 0
        Result
            Positions cursor at the center of the top line

    print[ <pathname>]
        Outputs a file to the printer

        Example
            print test
        Result
            Outputs test to the printer

    prompt <arbitrary>
        Changes the prompt variable

        Example
            prompt {{\n}!drive!path{ >}}
        Result
            Makes the prompt have a linefeed, drive, path,
            and greater than sign

    pwd (see path)

    quit
        Quits the program

        Example
            quit
        Result
            Terminates .ACCess!

    rd (see rmdir)

    rename <search pathname> <name>
        Renames files

        Example
            rename *.doc *.txt
        Result
            Renames DOC files to TXT files

    res (see resolution)

    resolution[ l|m]
        Returns resolution as low, medium, or high

        l changes to low resolution
        m changes to medium resolution

        Example
            echo {Resolution is }!resolution{\n}
        Output
            Resolution is <resolution>

    return[ <arbitrary>]
        Exits a batch file with an optional value

        Example
            return OK
        Result
            Exits a batch file with OK

    rm (see delete)

    rmdir <pathname>
        Removes a directory

        Example
            rmdir test
        Result
            Removes directory test

    rn (see rename)

    rndir <pathname> <name>
        Renames a directory

        Example
            rndir test temp
        Result
            Renames directory test to temp

    root <pathname> :: <pathname>
        Returns everything but extension

        Example
            echo {Root of c:\auto\access.bat = }!{root c:\auto\access.bat}{\n}
        Output
            Root of c:\auto\access.bat = c:\auto\access

    segment <arbitrary> <number>[ <number>] :: <arbitrary>
        Returns a segment from a starting position

        <number> returns a maximum number of characters

        Example
            echo {Segment of abc starting at 1 = }!{segment abc 1}{\n}
        Output
            Segment of abc starting at 1 = bc

    set <variable name> <arbitrary>
        sets a variable

        Example
            set x abc
        Result
            Sets the variable x to "abc"

    tail <pathname> :: <name>
        Returns everything but the path

        Example
            echo {Tail of c:\auto\access.bat = }!{tail c:\auto\access.bat}{\n}
        Output
            Tail of c:\auto\access.bat = access.bat

    time[ <time>] :: <time>
        Returns the time

        <time> change the time

        Example
            echo {Current time is }!time{\n}
        Output
            Current time is <current time>

    touch <pathname>
        Makes the file have the current date and time

        Example
            touch test
        Result
            Makes test have the current date and time

    type <pathname>
        Outputs a file to the console

        Example
            type test
        Result
            Outputs test to the screen

    unattrib[ -r][ -h][ -s][ -a] <search pathname>
        Unmarks attributes of a file with read only being the default

        -r unmarks read only
        -h unmarks hidden
        -s unmarks system
        -a unmarks archive

        Example
            unattrib -s -h ^c:\*.sys
        Result
            Unmarks system and hidden attributes of all files
            in device c: with extension of sys

    unlink (see delete)

    variables
        Display all variables

        Example
            variables
        Result
            Displays all variables and their values

    ver (see version)

    version
        Shows the version of the program

        Example
            version
        Result
            Shows the version of .ACCess!

    while <arbitrary><NEW LINE><command block>
        Does the command block while argument is non-empty
        The while command has an extra level for exiting the loop

        Example
            block < infile > outfile
                while !{not !eof}
                    set line !input
                    if {= $line quit}
                        exit 3
                    echo $line
        Result
            The file "infile" is copied to "outfile"
            If one of the lines is "quit" the copying is ended


****************************************************************
****************************************************************
                         END OF DOCUMENT
****************************************************************
****************************************************************